var express = require('express');
var router = express.Router();
const { Dynamics,UserModel } = require("../db/index");
const multiparty = require("multiparty");
const fs = require('fs');
const path = require('path');
const mongoose = require('mongoose');
const jwt = require('jsonwebtoken');
const ACCESS_TOKEN_SECRET = 'your_access_token_secret'; // 请确保与登录时一致

// function authMiddleware(req, res, next) {
//   const authHeader = req.headers['authorization'];
//   if (!authHeader) return res.status(401).json({ code: 401, message: '未登录' });
//   const token = authHeader.split(' ')[1];
//   if (!token) return res.status(401).json({ code: 401, message: '未登录' });
//   jwt.verify(token, ACCESS_TOKEN_SECRET, (err, user) => {
//     if (err) return res.status(403).json({ code: 403, message: 'token无效' });
//     req.userId = user.id;
//     next();
//   });
// }

router.post('/add', (req, res) => {
  console.log('收到 /add 请求');
  if (mongoose.connection.readyState !== 1) {
    console.error('数据库未连接，当前状态:', mongoose.connection.readyState);
    return res.status(500).json({
      code: 500,
      message: '数据库连接错误'
    });
  }

  const uploadDir = path.join(__dirname, '../upload');
  console.log('上传目录路径:', uploadDir);
  
  try {
    if (!fs.existsSync(uploadDir)) {
      console.log('创建上传目录');
      fs.mkdirSync(uploadDir, { recursive: true });
    }
  } catch (error) {
    console.error('创建上传目录失败:', error);
    return res.status(500).json({
      code: 500,
      message: '创建上传目录失败'
    });
  }

  const form = new multiparty.Form({
    uploadDir: uploadDir,
    maxFilesSize: 50 * 1024 * 1024, // 限制文件大小为50MB
    autoFiles: true,
    autoFields: true
  });

  form.parse(req, async (err, fields, files) => {
    if (err) {
      console.error('解析表单错误:', err);
      return res.status(400).json({
        code: 400,
        message: '提交失败'
      });
    }

    try {
      console.log('接收到的表单数据:', JSON.stringify(fields, null, 2));
      console.log('接收到的文件数据:', JSON.stringify(files, null, 2));

      if (!fields.title || !fields.address) {
        throw new Error('缺少必要字段');
      }

      let uploadedFileUrl = '';
      let mediaType = fields.media_type ? fields.media_type[0] : 'image';
      
      if (files.file && files.file.length > 0) {
        const file = files.file[0];
        console.log('处理文件:', file);

        // 验证文件类型
        const isImage = file.headers['content-type'].startsWith('image/');
        const isVideo = file.headers['content-type'].startsWith('video/');

        if (!isImage && !isVideo) {
          // 删除上传的文件
          fs.unlinkSync(file.path);
          throw new Error('只支持图片或视频文件');
        }

        // 验证文件大小
        const maxSize = isVideo ? 50 * 1024 * 1024 : 5 * 1024 * 1024; // 视频50MB，图片5MB
        if (file.size > maxSize) {
          // 删除上传的文件
          fs.unlinkSync(file.path);
          throw new Error(`文件大小不能超过${isVideo ? '50MB' : '5MB'}`);
        }

        // 验证视频格式
        if (isVideo) {
          const allowedVideoFormats = ['video/mp4', 'video/webm', 'video/ogg'];
          if (!allowedVideoFormats.includes(file.headers['content-type'])) {
            fs.unlinkSync(file.path);
            throw new Error('只支持 MP4, WebM, OGG 格式的视频');
          }

          // 为视频文件添加正确的扩展名
          const ext = file.headers['content-type'] === 'video/mp4' ? '.mp4' :
                     file.headers['content-type'] === 'video/webm' ? '.webm' :
                     '.ogg';
          
          const newPath = file.path + ext;
          fs.renameSync(file.path, newPath);
          file.path = newPath;
        }

        // 生成文件URL
        const fileName = path.basename(file.path);
        uploadedFileUrl = `/upload/${fileName}`;
        mediaType = isVideo ? 'video' : 'image';
        console.log('生成的文件URL:', uploadedFileUrl);
      }

      const dynamicData = {
        title: fields.title[0],
        address: fields.address[0],
        img: uploadedFileUrl,
        media_type: mediaType,
        comment: [],
        like: [],
        user_id: fields.user_id ? new mongoose.Types.ObjectId(fields.user_id[0]) : null,
        time: new Date()
      };

      console.log('准备创建的动态数据:', JSON.stringify(dynamicData, null, 2));

      const data = await Dynamics.create(dynamicData);
      console.log('创建成功的数据:', JSON.stringify(data, null, 2));

      // 返回完整的URL
      const responseData = data.toObject();
      responseData.img = `http://localhost:3000${responseData.img}`;

      res.json({
        code: 200,
        message: '发布成功',
        data: responseData
      });
    } catch (error) {
      console.error('创建动态错误:', error);
      console.error('错误堆栈:', error.stack);
      
      if (files && files.file) {
        files.file.forEach(file => {
          try {
            fs.unlinkSync(file.path);
          } catch (unlinkError) {
            console.error('清理临时文件失败:', unlinkError);
          }
        });
      }

      if (error.name === 'ValidationError') {
        return res.status(400).json({
          code: 400,
          message: '数据验证错误: ' + error.message
        });
      }

      if (error.name === 'CastError') {
        return res.status(400).json({
          code: 400,
          message: '数据格式错误: ' + error.message
        });
      }

      res.status(500).json({
        code: 500,
        message: error.message || '服务器错误'
      });
    }
  });
});

// 统一文件上传接口
router.post("/upload", (req, res) => {
  const uploadDir = path.join(__dirname, '../upload');
  if (!fs.existsSync(uploadDir)) {
    fs.mkdirSync(uploadDir, { recursive: true });
  }

  const form = new multiparty.Form({
    uploadDir: uploadDir
  });

  form.parse(req, (err, fields, files) => {
    if (err) {
      console.error('文件上传错误:', err);
      return res.status(400).json({
        code: 400,
        message: '文件上传失败'
      });
    }

    const uploadedFiles = files.file.map(file => {
      const relativePath = path.relative(path.join(__dirname, '..'), file.path);
      return {
        url: `http://localhost:3000/${relativePath.replace(/\\/g, '/')}`,
        filename: file.originalFilename
      };
    });

    res.json({
      code: 200,
      message: '上传成功',
      data: uploadedFiles
    });
  });
});

router.get('/list', async function(req, res) {
  try {
    console.log('开始获取动态列表');
    
    // 检查数据库连接状态
    if (mongoose.connection.readyState !== 1) {
      console.error('数据库未连接，当前状态:', mongoose.connection.readyState);
      return res.status(500).json({
        code: 500,
        message: '数据库连接错误'
      });
    }

    console.log('开始查询数据库');
    const data = await Dynamics.find({})
      .populate('user_id', 'userName img')
      .sort({ time: -1 });
    
    console.log('查询结果数量:', data.length);
    
    // 处理每个动态的URL
    const processedData = data.map(post => {
      const postObj = post.toObject();
      
      // 处理帖子图片/视频URL
      if (postObj.img) {
        // 如果img是对象（可能包含视频信息）
        if (typeof postObj.img === 'object' && postObj.img !== null) {
          console.log('处理视频对象:', postObj.img);
          // 尝试获取视频URL
          const videoUrl = postObj.img.src || postObj.img.url || postObj.img.path || '';
          postObj.img = videoUrl;
        }

        // 确保URL是字符串并添加域名
        if (typeof postObj.img === 'string' && !postObj.img.startsWith('http')) {
          postObj.img = `http://localhost:3000${postObj.img}`;
        }
      } else {
        postObj.img = '';
      }

      // 处理用户头像URL
      if (postObj.user_id && postObj.user_id.img && typeof postObj.user_id.img === 'string') {
        if (!postObj.user_id.img.startsWith('http')) {
          postObj.user_id.img = `http://localhost:3000${postObj.user_id.img}`;
        }
      }

      // 确保media_type字段存在
      if (!postObj.media_type) {
        // 根据文件扩展名判断媒体类型
        if (typeof postObj.img === 'string' && postObj.img) {
          const ext = postObj.img.toLowerCase().split('.').pop();
          if (ext && ['mp4', 'webm', 'ogg'].includes(ext)) {
            postObj.media_type = 'video';
          } else {
            postObj.media_type = 'image';
          }
        } else {
          postObj.media_type = 'image';
        }
      }

      // 确保评论和点赞数组存在
      postObj.comment = Array.isArray(postObj.comment) ? postObj.comment : [];
      postObj.like = Array.isArray(postObj.like) ? postObj.like : [];

      console.log('处理后的帖子:', {
        id: postObj._id,
        media_type: postObj.media_type,
        img: postObj.img
      });

      return postObj;
    });

    console.log('数据处理完成，准备返回');
    res.json({
      code: 200,
      message: '获取成功',
      data: processedData
    });
  } catch (err) {
    console.error('获取列表失败，详细错误:', err);
    console.error('错误堆栈:', err.stack);
    res.status(500).json({
      code: 500,
      message: '获取失败: ' + (err.message || '未知错误')
    });
  }
});

// 点赞接口
router.post('/like', async (req, res) => {
  const { postId, user_id } = req.body;
  if (!postId || !user_id) return res.status(400).json({ code: 400, message: '参数缺失' });

  try {
    const post = await Dynamics.findById(postId);
    if (!post) return res.status(404).json({ code: 404, message: '帖子不存在' });

    const likeIndex = post.like.indexOf(user_id);
    if (likeIndex > -1) {
      // 如果已经点赞，则取消点赞
      post.like.splice(likeIndex, 1);
    } else {
      // 如果没有点赞，则添加点赞
      post.like.push(user_id);
    }

    await post.save();
    res.json({ 
      code: 200, 
      message: likeIndex > -1 ? '取消点赞成功' : '点赞成功',
      like: post.like 
    });
  } catch (err) {
    console.error('点赞操作失败:', err);
    res.status(500).json({ code: 500, message: '服务器错误' });
  }
});

// 评论接口
router.post('/comment', async (req, res) => {
  const { postId, text, userId } = req.body;
  if (!postId || !text || !userId) return res.status(400).json({ code: 400, message: '参数缺失' });

  try {
    const post = await Dynamics.findById(postId);
    if (!post) return res.status(404).json({ code: 404, message: '帖子不存在' });

    const comment = {
      user_id: userId,
      text: text.trim(),
      timestamp: new Date()
    };

    if (!Array.isArray(post.comment)) {
      post.comment = [];
    }

    post.comment.push(comment);
    await post.save();

    res.json({ 
      code: 200, 
      message: '评论成功',
      comment: comment
    });
  } catch (err) {
    console.error('评论失败:', err);
    res.status(500).json({ code: 500, message: '服务器错误' });
  }
});

// 关注接口
router.post('/follow', async (req, res) => {
  const { followerId, followingId } = req.body;
  if (!followerId || !followingId) return res.status(400).json({ code: 400, message: '参数缺失' });
  if (followerId === followingId) return res.status(400).json({ code: 400, message: '不能关注自己' });

  try {
    const follower = await UserModel.findById(followerId);
    if (!follower) return res.status(404).json({ code: 404, message: '用户不存在' });

    if (follower.concern.includes(followingId)) {
      return res.json({ code: 200, message: '已经关注过了' });
    }

    follower.concern.push(followingId);
    await follower.save();

    res.json({ code: 200, message: '关注成功' });
  } catch (err) {
    console.error('关注失败:', err);
    res.status(500).json({ code: 500, message: '服务器错误' });
  }
});

// 关注/取消关注用户
router.post('/follow', async (req, res) => {
  try {
    const { followerId, followingId } = req.body;
    
    // 验证用户ID
    if (!followerId || !followingId) {
      return res.status(400).json({ code: 400, message: '参数缺失' });
    }

    // 获取关注者信息
    const follower = await UserModel.findById(followerId);
    if (!follower) {
      return res.status(404).json({ code: 404, message: '关注者不存在' });
    }

    // 获取被关注者信息
    const following = await UserModel.findById(followingId);
    if (!following) {
      return res.status(404).json({ code: 404, message: '被关注者不存在' });
    }

    // 检查是否已经关注
    const isFollowing = follower.concern.includes(followingId);
    
    if (isFollowing) {
      // 取消关注
      follower.concern = follower.concern.filter(id => id !== followingId);
      await follower.save();
      res.json({ code: 200, message: '取消关注成功' });
    } else {
      // 添加关注
      follower.concern.push(followingId);
      await follower.save();
      res.json({ code: 200, message: '成功关注' });
    }
  } catch (err) {
    console.error('关注操作失败:', err);
    res.status(500).json({ code: 500, message: '操作失败' });
  }
});

// 获取用户关注列表
router.get('/following/:userId', async (req, res) => {
  try {
    const userId = req.params.userId;
    const user = await UserModel.findById(userId);
    if (!user) {
      return res.status(404).json({ code: 404, message: '用户不存在' });
    }

    res.json({
      code: 200,
      message: '获取成功',
      following: user.concern || []
    });
  } catch (err) {
    console.error('获取关注列表失败:', err);
    res.status(500).json({
      code: 500,
      message: '获取失败'
    });
  }
});

// 获取用户信息
router.get('/user/:userId', async (req, res) => {
  try {
    const userId = req.params.userId;
    
    // 验证 userId 是否是有效的 MongoDB ObjectId
    if (!mongoose.Types.ObjectId.isValid(userId)) {
      return res.status(400).json({
        code: 400,
        message: '无效的用户ID'
      });
    }

    // 查找用户信息
    const user = await UserModel.findById(userId)
      .select('userName phone sex age money img concern')
      .lean();
    
    if (!user) {
      return res.status(404).json({
        code: 404,
        message: '用户不存在'
      });
    }

    // 转换数据格式以匹配前端需求
    const userData = {
      _id: user._id.toString(),
      userName: user.userName,
      phoneNumber: user.phone || '',
      gender: user.sex || '',
      age: user.age || 0,
      balance: user.money || 0,
      img: user.img || '',
      concern: user.concern || []
    };

    res.json({
      code: 200,
      message: '获取成功',
      data: userData
    });
  } catch (err) {
    console.error('获取用户信息失败:', err);
    res.status(500).json({
      code: 500,
      message: '服务器错误'
    });
  }
});

// 获取用户的所有帖子
router.get('/user/posts/:userId', async (req, res) => {
  try {
    const userId = req.params.userId;

    // 验证 userId 是否是有效的 MongoDB ObjectId
    if (!mongoose.Types.ObjectId.isValid(userId)) {
      return res.status(400).json({
        code: 400,
        message: '无效的用户ID'
      });
    }

    // 查找用户的所有帖子
    const posts = await Dynamics.find({ user_id: userId })
      .populate('user_id', 'userName img')
      .populate({
        path: 'comment.user_id',
        select: 'userName img'
      })
      .sort({ time: -1 });

    res.json({
      code: 200,
      message: '获取成功',
      data: posts
    });
  } catch (err) {
    console.error('获取用户帖子失败:', err);
    res.status(500).json({
      code: 500,
      message: '服务器错误'
    });
  }
});


module.exports = router;
